import { timeoutTask } from "../../../utils/index";
import { getUserInfo } from "../../../utils/storage";
// 骰子 key表示点数 value表示图片地址
const DICEINFO = {
  1: 'https://ustatic.hudongmiao.com/joymewBar/diceGameNew/1.png',
  2: 'https://ustatic.hudongmiao.com/joymewBar/diceGameNew/2.png',
  3: 'https://ustatic.hudongmiao.com/joymewBar/diceGameNew/3.png',
  4: 'https://ustatic.hudongmiao.com/joymewBar/diceGameNew/4.png',
  5: 'https://ustatic.hudongmiao.com/joymewBar/diceGameNew/5.png',
  6: 'https://ustatic.hudongmiao.com/joymewBar/diceGameNew/6.png',
};

const generateResultDicesByDiceStr = (diceStr) => {
  // diceStr 是字符串数组，如 ["2,5,5,1,5,4", "3,1,6,6,6,1", ...]
  if (!Array.isArray(diceStr) || diceStr.length === 0) {
    return [];
  }
  
  // 找到总和最大的那个字符串
  let maxSum = 0;
  let maxSumString = '';
  
  diceStr.forEach((diceString) => {
    // 将字符串按逗号分割成数组，计算总和
    const diceNumbers = diceString.split(',').map(num => parseInt(num.trim(), 10));
    const sum = diceNumbers.reduce((total, val) => total + val, 0);
    
    if (sum > maxSum) {
      maxSum = sum;
      maxSumString = diceString;
    }
  });
  
  // 如果找到最大值，生成对应的骰子数组
  if (maxSumString) {
    const diceNumbers = maxSumString.split(',').map(num => num.trim());
    const resultDices = diceNumbers.map((diceVal) => ({
      diceVal: diceVal,
      diceImg: DICEINFO[diceVal] || '',
    }));
    
    
    return resultDices;
  }
  
  console.log('generateResultDicesByDiceStr 返回空数组:', {
    input: diceStr,
    maxSumString: null
  });
  
  return [];
};

Component({
  /**
   * 组件的属性列表
   */
  properties: {
    // 控制弹框组件出现/隐藏
    dialogVisible: {
      value: false,
      type: Boolean,
    },
    // 当弹窗类型切换为 gameSuccess 时，兜底重新计算一次 scoreNumbers
    dialogType(newVal) {
      if (newVal === 'gameSuccess') {
        const myInfo = this.data.myInfo || this.properties.myInfo;
        if (myInfo && myInfo.score !== undefined && myInfo.score !== null && String(myInfo.score).length > 0) {
          const scoreNumbers = this.splitDiceVal(myInfo.score);
          this.setData({
            scoreNumbers: scoreNumbers,
          });
        }
      }
    },
    // 定义属性：dialogType 弹框类型
    // 类型：字符串
    // 取值：rule、record、challengeSuccess、challengeFail、gameSuccess、gameFail、gamePlay
    dialogType: {
      value: "",
      type: String,
    },
    // 本次投掷的次数（1/5/10），默认 1
    times: {
      value: 1,
      type: Number
    },
    diceVal: {
      value: "0",
      type: String
    },
    diceStr: {
      value: () => [],
      type: Array
    },
    playRecords: {
      value: () => [],
      type: Array
    },
    userInfo: {
      value: () => ({
        headImg: 'https://ustatic.hudongmiao.com/joymewMp/grayAvator.png',
        nickname: '用户'
      }),
      type: Object
    },
    rank: {
      value: 0,
      type: Number
    },
    // 我的奖品数据
    // 数据结构：{ prizeName: '奖品名称', prizeImg: '奖品图片URL', ... }
    myAwardData: {
      value: () => ({}),
      type: Object
    },
    // 我的信息
    // 数据结构：{ wx_name: '微信昵称', score: 25, USER_ID: '用户ID', avator: '头像URL' }
    myInfo: {
      value: () => ({}),
      type: Object
    },
    // 排行榜数据
    // 数据结构：[{ avator: '头像URL', wx_name: '微信昵称', score: 25, rank: 1 }, ...]
    ranklist: {
      value: () => [],
      type: Array
    },
    // 奖品数据
    // 数据结构：[{ prizeName: '奖品名称', prizeImg: '奖品图片URL', prizeDesc: '奖品描述' }, ...]
    awardData: {
      value: () => [],
      type: Array
    }
  },
  observers: {
    // 监听dialogVisible的变化
    // 弹窗盒子默认是隐藏的
    // 如果为true 执行出现的过渡动画,动画执行完毕(300ms)后，显示弹框盒子
    dialogVisible(newVal) {
      if (newVal) {
        this.setData({
          transitionAnimationShow: true,
        });
        timeoutTask(() => {
          this.setData({
            dialogBoxVisible: true,
          });
        }, 300);
      }
    },
    diceStr(newVal) {
      if(newVal) {
        const tmpResultDices = generateResultDicesByDiceStr(newVal);
        
        // 计算总和数据
        let sumResults = [];
        if (Array.isArray(newVal) && newVal.length > 0) {
          let maxSum = 0;
          sumResults = newVal.map((diceString, index) => {
            // 确保 diceString 是字符串类型
            if (typeof diceString === 'string') {
              const diceArr = diceString.split(',');
              const sum = diceArr.reduce((total, val) => total + parseInt(val.trim(), 10), 0);
              if (sum > maxSum) {
                maxSum = sum;
              }
              return {
                value: sum,
                isMax: false
              };
            }
            return {
              value: 0,
              isMax: false
            };
          });
          
          // 设置最大值为高亮
          sumResults.forEach(item => {
            if (item.value === maxSum) {
              item.isMax = true;
            }
          });
        }
        
        this.setData({
          resultDices: tmpResultDices,
          sumResults: sumResults,
        })
      }
    },
    diceVal(newVal) {
      if(newVal) {
        const diceValNumbers = this.splitDiceVal(newVal);
        this.setData({
          diceValNumbers: diceValNumbers,
        })
      }
    },
    myInfo(newVal, oldVal) {
      if(newVal && newVal.score) {
        const scoreNumbers = this.splitDiceVal(newVal.score);
        this.setData({
          scoreNumbers: scoreNumbers,
        })
      }
    },
    // 监听 ranklist，生成第一名分数字符串数组用于游戏结束弹窗
    ranklist(newVal) {
      if (Array.isArray(newVal) && newVal.length > 0 && newVal[0] && newVal[0].score !== undefined && newVal[0].score !== null) {
        const firstScoreNumbers = this.splitDiceVal(newVal[0].score);
        this.setData({
          scoreNumbersFirst: firstScoreNumbers,
        });
      } else {
        this.setData({
          scoreNumbersFirst: [],
        });
      }
    }
  },
  data: {
    // 定义变量：transitionAnimationShow
    // 控制弹框盒子出现/隐藏的过渡动画
    transitionAnimationShow: false,
    // 定义变量：dialogBoxVisible
    // 控制弹框盒子出现/隐藏
    dialogBoxVisible: false,
    resultDices: [],
    // 拆分后的数字数组，用于渲染艺术字图片
    diceValNumbers: [],
    // 拆分后的分数数字数组，用于渲染艺术字图片
    scoreNumbers: [],
    // 第一名分数拆分后的数字数组，仅用于 endDialogBox
    scoreNumbersFirst: [],
    // 从storage获取的用户信息
    currentUserInfo: {
      headImg: 'https://ustatic.hudongmiao.com/joymewMp/grayAvator.png',
      nickname: '用户'
    },
    // SVGA 动画配置
    // diceShakeEffectConfig: {
    //   svgaPath: 'https://static.hudongmiao.com/joymewBar/diceGameNew/dicePlaySuccessEffect.svga',
    //   cWidth: 700,
    //   cHeight: 700,
    //   top: 30,
    //   left: -135,
    //   zIndex: 0
    // }
  },
  attached() {
    // 组件初始化时从storage获取用户信息
    this.loadUserInfo();
    // 初始化时处理 myInfo 数据
    this.handleMyInfoData();
    // 延迟处理，确保数据已经传递
    setTimeout(() => {
      this.handleMyInfoData();
    }, 100);
  },
  /**
   * 组件的方法列表
   */
  methods: {
    // 拆分diceVal数字，返回数字数组
    splitDiceVal(diceVal) {
      const diceValStr = String(diceVal);
      return diceValStr.split('');
    },
    // 处理 myInfo 数据
    handleMyInfoData() {
      const myInfo = this.data.myInfo || this.properties.myInfo;
      if(myInfo && myInfo.score) {
        const scoreNumbers = this.splitDiceVal(myInfo.score);
        this.setData({
          scoreNumbers: scoreNumbers,
        })
      }
    },
    // 从storage加载用户信息
    loadUserInfo() {
      const userInfo = getUserInfo();
      if (userInfo && userInfo.nickName && userInfo.avatarUrl) {
        this.setData({
          currentUserInfo: {
            headImg: userInfo.avatarUrl,
            nickname: userInfo.nickName
          }
        });
      }
    },
    // 关闭弹窗
    // 1、执行关闭动画 2、关闭弹窗盒子和弹窗组件
    closeDialog() {
      this.setData({
        transitionAnimationShow: false,
      });
      timeoutTask(() => {
        this.setData({
          dialogBoxVisible: false,
          dialogVisible: false,
        });
        this.triggerEvent('dialogClose');
      }, 300);
    },
    
    // SVGA 动画播放完成回调
    // onDiceShakeEffectFinished() {
    //   console.log('骰子摇奖动画播放完成');
    //   // 可以在这里添加动画完成后的逻辑
    //   this.triggerEvent('diceShakeEffectFinished');
    // },
    
    // SVGA 动画加载失败回调
    // onDiceShakeEffectLoadError(e) {
    //   console.error('骰子摇奖动画加载失败:', e.detail.error);
    //   // 可以在这里添加错误处理逻辑
    //   this.triggerEvent('diceShakeEffectLoadError', e.detail);
    // },
    
    // 手动触发骰子摇奖动画播放
    // playDiceShakeEffect() {
    //   // 通过选择器获取 SVGA 组件实例并触发播放
    //   const svgaComponent = this.selectComponent('.svga-effect-common');
    //   if (svgaComponent) {
    //     svgaComponent.canPlayAni();
    //   }
    // },
    
    // 成功确认按钮点击事件
    onSuccessConfirm() {
      this.triggerEvent('endconfirm');
    },
  },
});
